home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / procssng / ccs / ccs-11tl.lha / lbl / xview / genial / lib / c_array.c next >
Encoding:
C/C++ Source or Header  |  1992-07-14  |  18.2 KB  |  821 lines
  1.  
  2. /*
  3.  *     c_array.c   a collection of routines for handeling
  4.  *                 dynamically allocated arrays in C.  
  5.  *
  6.  *     Brian Tierney  LBL
  7.  *
  8.  *  This routines allocate and access array by creating arrays of pointers.
  9.  *   The reason for these routines are speed and code readability. Allocating
  10.  *   arrays in this manner means that elements can be accessed by pointers
  11.  *   instead of by a multiplication and an addition. This method uses more 
  12.  *   memory, but on a machine with plenty of memory the increase in speed 
  13.  *   is worth it.  
  14.  *
  15.  *    for example, this:
  16.  * 
  17.  *       for (r = 0; r < nrow; r++)
  18.  *           for (c = 0; c < ncol; c++) {
  19.  *            pixel = image[r][c];
  20.  *
  21.  * is faster and more readable (in my opinion), than this:
  22.  *
  23.  *       for (r = 0; r < nrow; r++)
  24.  *           for (c = 0; c < ncol; c++) {
  25.  *            pixel = image[r * nrow + c];
  26.  */
  27.  
  28. /* routines in this file:
  29.  
  30.       alloc_3d_byte_array(nx,ny,nz)
  31.       alloc_2d_byte_array(nx,ny)
  32.       read_3d_byte_array(fp,array,nx,ny,nz)
  33.       read_2d_byte_array(fp,array,nx ,ny)
  34.       write_3d_byte_array(fp,array,nx,ny,nz)
  35.       write_2d_byte_array(fp,array,nx,ny)
  36.       free_3d_byte_array(array)
  37.       free_2d_byte_array(array)
  38.  
  39.   ** and same routines for short, int, and float
  40.  
  41.   *
  42.   *  all read/write routines return a 0 if successful and 1 otherwise 
  43.   *
  44.   *
  45.   *  sample use with hips images:  r=rows, c=cols, f = frames
  46.   *    2D case:
  47.   *    u_char **pic;
  48.   *    pic = alloc_2d_byte_array(r,c);
  49.   *    read_2d_byte_array(stdin, pic1, r,c);
  50.   *
  51.   *    for (i = 0; i < r; i++)
  52.   *    for (j = 0; j < c; j++)  {  * want column to vary fastest *
  53.   *        val = pic[i][j]; 
  54.   *    }
  55.   *    write_2d_byte_array(stdout, pic2, r,c); 
  56.   *
  57.   ****************************************************
  58.   *   3D case:
  59.   *    u_char **pic;
  60.   *    pic = alloc_3d_byte_array(f,r,c);
  61.   *  
  62.   *  read_3d_byte_array(stdin, pic, f,r,c);
  63.   *    
  64.   *   for (i = 0; i < f; i++)
  65.   *      for (j = 0; j < r; j++)  
  66.   *        for(k=0; k< c; k++) {  * vary col fastest, frame slowest *
  67.   *            val = pic[i][j][k]; 
  68.   */
  69.  
  70. /***********************************************************************/
  71. /*  COPYRIGHT NOTICE         *******************************************/
  72. /***********************************************************************/
  73.  
  74. /*   This program is copyright (C) 1990, Regents  of  the
  75. University  of  California.   Anyone may reproduce this software,
  76. in whole or in part, provided that:
  77. (1)  Any copy  or  redistribution  must  show  the
  78.      Regents  of  the  University of California, through its
  79.      Lawrence Berkeley Laboratory, as the source,  and  must
  80.      include this notice;
  81. (2)  Any use of this software must reference this  distribu-
  82.      tion,  state that the software copyright is held by the
  83.      Regents of the University of California, and  that  the
  84.      software is used by their permission.
  85.  
  86.      It is acknowledged that the U.S. Government has  rights
  87. to this software under  Contract DE-AC03-765F00098 between the U.S.
  88. Department of Energy and the University of California.
  89.  
  90.      This software is provided as a professional  academic
  91. contribution for  joint exchange.  Thus it is experimental, is
  92. provided ``as is'', with no warranties of any kind  whatsoever,
  93. no  support,  promise  of updates, or printed documentation.
  94. Bug reports or fixes may be sent to the author, who may or may
  95. not act on them as he desires.
  96. */
  97.  
  98. /*   Author:  Brian L. Tierney
  99.  *            Lawrence Berkeley Laboratory
  100.  *            Imaging and Distributed Computing Group
  101.  *            email: bltierney@lbl.gov
  102. */
  103.  
  104. #include <stdio.h>
  105. #include <sys/types.h>
  106.  
  107. #define Calloc(x,y) (y *)calloc((unsigned)(x), sizeof(y))
  108. #define Fread(a,b,c,d) fread((char *)(a), b, (int)(c), d)
  109. #define Fwrite(a,b,c,d) fwrite((char *)(a), b, (int)(c), d)
  110.  
  111. /*********************************/
  112. u_char ***
  113. alloc_3d_byte_array(nx,ny,nz)  /* in hips terminology: col,row,frame */
  114. int nx,ny,nz;
  115. {
  116.     u_char ***array;
  117.     register int i, j;
  118.  
  119.     /* allocate 3-d array for input image data */
  120.  
  121.     /* allocate 2 arrays of pointers */
  122.     if ((array = Calloc(nx, u_char **)) == NULL)
  123.     perror("calloc error: array ");
  124.     if ((array[0] = Calloc(nx * ny, u_char *)) == NULL)
  125.     perror("calloc error: array ");
  126.  
  127.     /* allocate array for data */
  128.     if ((array[0][0] = Calloc(nx * ny * nz, u_char)) ==    NULL)
  129.     perror("calloc error: array ");
  130.  
  131.     /* initialize pointer arrays */
  132.     for (i = 1; i < ny; i++)
  133.     array[0][i] = **array + (nz * i);
  134.     for (i = 1; i < nx; i++) {
  135.     array[i] = *array + (ny * i);
  136.     array[i][0] = **array + (nz * ny * i);
  137.     for (j = 1; j < ny; j++)/* initialize pointer array */
  138.         array[i][j] = array[i][0] + (nz * j);
  139.     }
  140.     return(array);
  141. }
  142.  
  143. /**********************************/
  144. u_char **
  145. alloc_2d_byte_array(nx,ny)
  146. int nx,ny;
  147. {
  148.     u_char **array;
  149.     register int i;
  150.  
  151.     /* allocate 2-d array for input image data */
  152.     /* allocate array of pointers */
  153.     if ((array = Calloc(nx, u_char *)) == NULL)
  154.     perror("calloc error: array ");
  155.  
  156.     /* allocate array for data */
  157.     if ((array[0] = Calloc(nx * ny, u_char)) == NULL)
  158.     perror("calloc error: array ");
  159.  
  160.     /* initialize pointer arrays */
  161.     for (i = 1; i < nx; i++) 
  162.     array[i] = array[0] + (ny * i);
  163.  
  164.     return(array);
  165. }
  166.  
  167. /**********************************/
  168. char **
  169. alloc_2d_char_array(nx,ny)
  170. int nx,ny;
  171. {
  172.     char **array;
  173.     register int i;
  174.  
  175.     /* allocate 2-d array for input image data */
  176.     /* allocate array of pointers */
  177.     if ((array = Calloc(nx, char *)) == NULL)
  178.     perror("calloc error: array ");
  179.  
  180.     /* allocate array for data */
  181.     if ((array[0] = Calloc(nx * ny, char)) == NULL)
  182.     perror("calloc error: array ");
  183.  
  184.     /* initialize pointer arrays */
  185.     for (i = 1; i < nx; i++) 
  186.     array[i] = array[0] + (ny * i);
  187.  
  188.     return(array);
  189. }
  190. /********************************/
  191. int
  192. read_3d_byte_array(fp,array,nx,ny,nz)
  193. FILE *fp;
  194. u_char ***array;
  195. int nx,ny,nz;
  196. {
  197.     long      rsize;
  198.  
  199.     rsize = nx * ny * nz; 
  200.     if (Fread(array[0][0], sizeof(u_char), rsize, fp)  != rsize) {
  201.     perror("\n error reading file\n");
  202.     return(-1);
  203.     }
  204.     return(0);
  205. }
  206.  
  207. /********************************/
  208. int
  209. read_2d_byte_array(fp,array,nx ,ny)
  210. FILE *fp;
  211. u_char **array;
  212. int nx,ny;
  213. {
  214.     long      rsize;
  215.  
  216.     rsize = nx * ny; 
  217.  
  218.     if (Fread(array[0], sizeof(u_char), rsize, fp)  != rsize) {
  219.         perror("\n error reading file\n"); 
  220.         return (-1);
  221.     } 
  222.  
  223.     return(0);
  224. }
  225.  
  226. /*******************************/
  227. int
  228. write_3d_byte_array(fp,array,nx,ny,nz)
  229. FILE *fp;
  230. u_char ***array;
  231. int nx,ny,nz;
  232. {
  233.     long      size;
  234.  
  235.     size = nx * ny * nz;  
  236.     if (Fwrite(array[0][0], sizeof(u_char), size, fp)  != size) {
  237.     perror("\n error writing file\n");
  238.     return (-1);
  239.     }
  240.  
  241.     return(0);
  242. }
  243.  
  244. /********************************/
  245. int
  246. write_2d_byte_array(fp,array,nx ,ny)
  247. FILE *fp;
  248. u_char **array;
  249. int nx,ny;
  250. {
  251.     long      size;
  252.  
  253.     size = nx* ny; 
  254.  
  255.     if (Fwrite(array[0], sizeof(u_char), size, fp)  != size) {
  256.     perror("\n error writing file\n");
  257.     return(-1);
  258.     }
  259.     return(0);
  260. }
  261.  
  262. /********************************/
  263. int
  264. free_3d_byte_array(array)
  265. u_char ***array;
  266. {
  267.     cfree((char *)array[0][0]);
  268.     cfree((char *)array[0]);
  269.     cfree((char *)array);
  270. }
  271.  
  272. /*********************************/
  273. int
  274. free_2d_byte_array(array)
  275. u_char **array;
  276. {
  277.     cfree((char *)array[0]);
  278.     cfree((char *)array);
  279. }
  280.  
  281. /********************************************************/
  282. /* same routines for data type short                    */
  283. /********************************************************/
  284.  
  285. short ***
  286. alloc_3d_short_array(nx,ny,nz)
  287. int nx,ny,nz;
  288. {
  289.     short ***array;
  290.     register int i, j;
  291.  
  292.     /* allocate 3-d array for input image data */
  293.  
  294.     /* allocate 2 arrays of pointers */
  295.     if ((array = Calloc(nx, short **)) == NULL)
  296.     perror("calloc error: array ");
  297.     if ((array[0] = Calloc(nx * ny, short *)) == NULL)
  298.     perror("calloc error: array ");
  299.  
  300.     /* allocate array for data */
  301.     if ((array[0][0] = Calloc(nx * ny * nz, short)) ==    NULL)
  302.     perror("calloc error: array ");
  303.  
  304.     /* initialize pointer arrays */
  305.     for (i = 1; i < ny; i++)
  306.     array[0][i] = **array + (nz * i);
  307.     for (i = 1; i < nx; i++) {
  308.     array[i] = *array + (ny * i);
  309.     array[i][0] = **array + (ny * nz * i);
  310.     for (j = 1; j < ny; j++)/* initialize pointer array */
  311.         array[i][j] = array[i][0] + (nz * j);
  312.     }
  313.     return(array);
  314. }
  315.  
  316. /**********************************/
  317. short **
  318. alloc_2d_short_array(nx,ny)
  319. int nx,ny;
  320. {
  321.     short **array;
  322.     register int i;
  323.  
  324.     /* allocate 2-d array for input image data */
  325.     /* allocate array of pointers */
  326.     if ((array = Calloc(nx, short *)) == NULL)
  327.     perror("calloc error: array ");
  328.  
  329.     /* allocate array for data */
  330.     if ((array[0] = Calloc(nx * ny, short)) == NULL)
  331.     perror("calloc error: array ");
  332.  
  333.     /* initialize pointer arrays */
  334.     for (i = 0; i < nx; i++) 
  335.     array[i] = *array + (ny * i);
  336.  
  337.     return(array);
  338. }
  339.  
  340. /********************************/
  341. int
  342. read_3d_short_array(fp,array,nx,ny,nz)
  343. FILE *fp;
  344. short ***array;
  345. int nx,ny,nz;
  346. {
  347.     long      rsize;
  348.  
  349.     rsize = nx * ny * nz; 
  350.     if (Fread(array[0][0], sizeof(short), rsize, fp)  != rsize) {
  351.     perror("\n error reading file\n");
  352.     return(-1);
  353.     }
  354.     return(0);
  355. }
  356.  
  357. /********************************/
  358. int
  359. read_2d_short_array(fp,array,nx ,ny)
  360. FILE *fp;
  361. short **array;
  362. int nx,ny;
  363. {
  364.     long      rsize;
  365.  
  366.     rsize = nx * ny; 
  367.     if (Fread(array[0], sizeof(short), rsize, fp)  != rsize) {
  368.         perror("\n error reading file\n");
  369.         return(-1);
  370.     }
  371.     return(0);
  372. }
  373.  
  374. /*******************************/
  375. int
  376. write_3d_short_array(fp,array,nx,ny,nz)
  377. FILE *fp;
  378. short ***array;
  379. int nx,ny,nz;
  380. {
  381.     long      size;
  382.  
  383.     size = nx * ny * nz;  
  384.     if (Fwrite(array[0][0], sizeof(short), size, fp)  != size) {
  385.     perror("\n error writing file\n");
  386.     return(-1);
  387.     }
  388.     return(0);
  389. }
  390.  
  391. /********************************/
  392. int
  393. write_2d_short_array(fp,array,nx ,ny)
  394. FILE *fp;
  395. short **array;
  396. int nx,ny;
  397. {
  398.     long      size;
  399.  
  400.     size = nx* ny; 
  401.  
  402.     if (Fwrite(array[0], sizeof(short), size, fp)  != size) {
  403.     perror("\n error writing file\n");
  404.     return(-1);
  405.     }
  406.     return(0);
  407. }
  408.  
  409. /********************************/
  410. int
  411. free_3d_short_array(array)
  412. short ***array;
  413. {
  414.     cfree((char *)array[0][0]);
  415.     cfree((char *)array[0]);
  416.     cfree((char *)array);
  417. }
  418.  
  419. /*********************************/
  420. int
  421. free_2d_short_array(array)
  422. short **array;
  423. {
  424.     cfree((char *)array[0]);
  425.     cfree((char *)array);
  426. }
  427.  
  428. /****************************************************/
  429. /*  int routines */
  430. /**************************************************/
  431.  
  432. int ***
  433. alloc_3d_int_array(nx,ny,nz)
  434. int nx,ny,nz;
  435. {
  436.     int ***array;
  437.     register int i, j;
  438.  
  439.     /* allocate 3-d array for input image data */
  440.  
  441.     /* allocate 2 arrays of pointers */
  442.     if ((array = Calloc(nx, int **)) == NULL)
  443.     perror("calloc error: array ");
  444.     if ((array[0] = Calloc(nx * ny, int *)) == NULL)
  445.     perror("calloc error: array ");
  446.  
  447.     /* allocate array for data */
  448.     if ((array[0][0] = Calloc(nx * ny * nz, int)) ==    NULL)
  449.     perror("calloc error: array ");
  450.  
  451.     /* initialize pointer arrays */
  452.     for (i = 1; i < ny; i++)
  453.     array[0][i] = **array + (nz * i);
  454.     for (i = 1; i < nx; i++) {
  455.     array[i] = *array + (ny * i);
  456.     array[i][0] = **array + (ny * nz * i);
  457.     for (j = 1; j < ny; j++)/* initialize pointer array */
  458.         array[i][j] = array[i][0] + (nz * j);
  459.     }
  460.     return(array);
  461. }
  462.  
  463. /**********************************/
  464. int **
  465. alloc_2d_int_array(nx,ny)
  466. int nx,ny;
  467. {
  468.     int **array;
  469.     register int i;
  470.  
  471.     /* allocate 2-d array for input image data */
  472.     /* allocate array of pointers */
  473.     if ((array = Calloc(nx, int *)) == NULL)
  474.     perror("calloc error: array ");
  475.  
  476.     /* allocate array for data */
  477.     if ((array[0] = Calloc(nx * ny, int)) == NULL)
  478.     perror("calloc error: array ");
  479.  
  480.     /* initialize pointer arrays */
  481.     for (i = 0; i < nx; i++) 
  482.     array[i] = *array + (ny * i);
  483.  
  484.     return(array);
  485. }
  486.  
  487. /********************************/
  488. int
  489. read_3d_int_array(fp,array,nx,ny,nz)
  490. FILE *fp;
  491. int ***array;
  492. int nx,ny,nz;
  493. {
  494.     long      rsize;
  495.  
  496.     rsize = nx * ny * nz; 
  497.     if (Fread(array[0][0], sizeof(int), rsize, fp)  != rsize) {
  498.     perror("\n error reading file\n");
  499.     return(-1);
  500.     }
  501.     return(0);
  502. }
  503.  
  504. /********************************/
  505. int
  506. read_2d_int_array(fp,array,nx ,ny)
  507. FILE *fp;
  508. int **array;
  509. int nx,ny;
  510. {
  511.     long      rsize;
  512.  
  513.     rsize = nx * ny; 
  514.     if (Fread(array[0], sizeof(int), rsize, fp)  != rsize) {
  515.         perror("\n error reading file\n");
  516.         return(-1);
  517.     }
  518.     return(0);
  519. }
  520.  
  521. /*******************************/
  522. int
  523. write_3d_int_array(fp,array,nx,ny,nz)
  524. FILE *fp;
  525. int ***array;
  526. int nx,ny,nz;
  527. {
  528.     long      size;
  529.  
  530.     size = nx * ny * nz;  
  531.     if (Fwrite(array[0][0], sizeof(int), size, fp)  != size) {
  532.     perror("\n error writing file\n");
  533.     return(-1);
  534.     }
  535.     return(0);
  536. }
  537.  
  538. /********************************/
  539. int
  540. write_2d_int_array(fp,array,nx ,ny)
  541. FILE *fp;
  542. int **array;
  543. int nx,ny;
  544. {
  545.     long      size;
  546.  
  547.     size = nx* ny; 
  548.  
  549.     if (Fwrite(array[0], sizeof(int), size, fp)  != size) {
  550.     perror("\n error writing file\n");
  551.     return(-1);
  552.     }
  553.     return(0);
  554. }
  555.  
  556. /********************************/
  557. int
  558. free_3d_int_array(array)
  559. int ***array;
  560. {
  561.     cfree((char *)array[0][0]);
  562.     cfree((char *)array[0]);
  563.     cfree((char *)array);
  564. }
  565.  
  566. /*********************************/
  567. int
  568. free_2d_int_array(array)
  569. int **array;
  570. {
  571.     cfree((char *)array[0]);
  572.     cfree((char *)array);
  573. }
  574.  
  575. /****************************************************/
  576. /*  float routines */
  577. /**************************************************/
  578.  
  579. float ***
  580. alloc_3d_float_array(nx,ny,nz)
  581. int nx,ny,nz;
  582. {
  583.     float ***array;
  584.     register int i, j;
  585.  
  586.     /* allocate 3-d array for input image data */
  587.  
  588.     /* allocate 2 arrays of pointers */
  589.     if ((array = Calloc(nx, float **)) == NULL)
  590.     perror("calloc error: array ");
  591.     if ((array[0] = Calloc(nx * ny, float *)) == NULL)
  592.     perror("calloc error: array ");
  593.  
  594.     /* allocate array for data */
  595.     if ((array[0][0] = Calloc(nx * ny * nz, float)) ==    NULL)
  596.     perror("calloc error: array ");
  597.  
  598.     /* initialize pointer arrays */
  599.     for (i = 1; i < ny; i++)
  600.     array[0][i] = **array + (nz * i);
  601.     for (i = 1; i < nx; i++) {
  602.     array[i] = *array + (ny * i);
  603.     array[i][0] = **array + (ny * nz * i);
  604.     for (j = 1; j < ny; j++)/* initialize pointer array */
  605.         array[i][j] = array[i][0] + (nz * j);
  606.     }
  607.     return(array);
  608. }
  609.  
  610. /**********************************/
  611. float **
  612. alloc_2d_float_array(nx,ny)
  613. int nx,ny;
  614. {
  615.     float **array;
  616.     register int i;
  617.  
  618.     /* allocate 2-d array for input image data */
  619.     /* allocate array of pointers */
  620.     if ((array = Calloc(nx, float *)) == NULL)
  621.     perror("calloc error: array ");
  622.  
  623.     /* allocate array for data */
  624.     if ((array[0] = Calloc(nx * ny, float)) == NULL)
  625.     perror("calloc error: array ");
  626.  
  627.     /* initialize pointer arrays */
  628.     for (i = 0; i < nx; i++) 
  629.     array[i] = *array + (ny * i);
  630.  
  631.     return(array);
  632. }
  633.  
  634. /********************************/
  635. int
  636. read_3d_float_array(fp,array,nx,ny,nz)
  637. FILE *fp;
  638. float ***array;
  639. int nx,ny,nz;
  640. {
  641.     long      rsize;
  642.  
  643.     rsize = nx * ny * nz; 
  644.     if (Fread(array[0][0], sizeof(float), rsize, fp)  != rsize) {
  645.     perror("\n error reading file\n");
  646.     return(-1);
  647.     }
  648.     return(0);
  649. }
  650.  
  651. /********************************/
  652. int
  653. read_2d_float_array(fp,array,nx ,ny)
  654. FILE *fp;
  655. float **array;
  656. int nx,ny;
  657. {
  658.     long      rsize;
  659.  
  660.     rsize = nx * ny; 
  661.     if (Fread(array[0], sizeof(float), rsize, fp)  != rsize) {
  662.         perror("\n error reading file\n");
  663.         return(-1);
  664.     }
  665.     return(0);
  666. }
  667.  
  668. /*******************************/
  669. int
  670. write_3d_float_array(fp,array,nx,ny,nz)
  671. FILE *fp;
  672. float ***array;
  673. int nx,ny,nz;
  674. {
  675.     long      size;
  676.  
  677.     size = nx * ny * nz;  
  678.     if (Fwrite(array[0][0], sizeof(float), size, fp)  != size) {
  679.     perror("\n error writing file\n");
  680.     return(-1);
  681.     }
  682.     return(0);
  683. }
  684.  
  685. /********************************/
  686. int
  687. write_2d_float_array(fp,array,nx ,ny)
  688. FILE *fp;
  689. float **array;
  690. int nx,ny;
  691. {
  692.     long      size;
  693.  
  694.     size = nx* ny; 
  695.  
  696.     if (Fwrite(array[0], sizeof(float), size, fp)  != size) {
  697.     perror("\n error writing file\n");
  698.     return(-1);
  699.     }
  700.     return(0);
  701. }
  702.  
  703. /********************************/
  704. int
  705. free_3d_float_array(array)
  706. float ***array;
  707. {
  708.     cfree((char *)array[0][0]);
  709.     cfree((char *)array[0]);
  710.     cfree((char *)array);
  711. }
  712.  
  713. /*********************************/
  714. int
  715. free_2d_float_array(array)
  716. float **array;
  717. {
  718.     cfree((char *)array[0]);
  719.     cfree((char *)array);
  720. }
  721.  
  722. /**************************************************************/
  723. /*                  long routines                             */
  724. /**************************************************************/
  725.  
  726. long ***
  727. alloc_3d_long_array(nx,ny,nz)  /* in hips terminology: col,row,frame */
  728. int nx,ny,nz;
  729. {
  730.     long ***array;
  731.     register int i, j;
  732.  
  733.     /* allocate 3-d array for input image data */
  734.  
  735.     /* allocate 2 arrays of pointers */
  736.     if ((array = Calloc(nx, long **)) == NULL)
  737.     perror("calloc error: array ");
  738.     if ((array[0] = Calloc(nx * ny, long *)) == NULL)
  739.     perror("calloc error: array ");
  740.  
  741.     /* allocate array for data */
  742.     if ((array[0][0] = Calloc(nx * ny * nz, long)) ==    NULL)
  743.     perror("calloc error: array ");
  744.  
  745.     /* initialize pointer arrays */
  746.     for (i = 1; i < ny; i++)
  747.     array[0][i] = **array + (nz * i);
  748.     for (i = 1; i < nx; i++) {
  749.     array[i] = *array + (ny * i);
  750.     array[i][0] = **array + (nz * ny * i);
  751.     for (j = 1; j < ny; j++)/* initialize pointer array */
  752.         array[i][j] = array[i][0] + (nz * j);
  753.     }
  754.     return(array);
  755. }
  756.  
  757. /**********************************/
  758. long **
  759. alloc_2d_long_array(nx,ny)
  760. int nx,ny;
  761. {
  762.     long **array;
  763.     register int i;
  764.  
  765.     /* allocate 2-d array for input image data */
  766.     /* allocate array of pointers */
  767.     if ((array = Calloc(nx, long *)) == NULL)
  768.     perror("calloc error: array ");
  769.  
  770.     /* allocate array for data */
  771.     if ((array[0] = Calloc(nx * ny, long)) == NULL)
  772.     perror("calloc error: array ");
  773.  
  774.     /* initialize pointer arrays */
  775.     for (i = 0; i < nx; i++) 
  776.     array[i] = *array + (ny * i);
  777.  
  778.     return(array);
  779. }
  780.  
  781. /********************************/
  782. int
  783. free_3d_long_array(array)
  784. long ***array;
  785. {
  786.     cfree((char *)array[0][0]);
  787.     cfree((char *)array[0]);
  788.     cfree((char *)array);
  789. }
  790.  
  791. /*********************************/
  792. int
  793. free_2d_long_array(array)
  794. long **array;
  795. {
  796.     cfree((char *)array[0]);
  797.     cfree((char *)array);
  798. }
  799.  
  800. /***********************************************************************/
  801. /*  all types: all use these if array is cast when calling the routine */
  802. /***********************************************************************/
  803. int
  804. free_3d_array(array)
  805. char ***array;
  806. {
  807.     cfree(array[0][0]);
  808.     cfree(array[0]);
  809.     cfree(array);
  810. }
  811.  
  812. /*********************************/
  813. int
  814. free_2d_array(array)
  815. char **array;
  816. {
  817.     cfree(array[0]);
  818.     cfree(array);
  819. }
  820.  
  821.